Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 skin-theme-clientpref-day vector-sticky-header-enabled" lang="de" dir="ltr"><head>
<meta charset="UTF-8">
<title>Framebuffer</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://de.wikipedia.org/wiki/Framebuffer"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.math.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link href="./_mw_/ext.gadget.citeRef.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.defaultPlainlinks.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonHide.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonLayout.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiCommonStyle.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiDarkmode.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.dewikiResponsive.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.gadget.specialSearch.css" rel="stylesheet" type="text/css">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Framebuffer rootpage-Framebuffer skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">Framebuffer</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr"><div style="margin:1em auto; border:3px double #EEB422; padding:1em; background:var(--background-color-base, #FFFFFF); color:var(--color-base, #202122); border-radius:1em; font-size: 90%; overflow:hidden; max-width:90%;">
<table>
<tbody><tr>
<td class="noresize">
</td>
<td>Dieser Artikel wurde wegen inhaltlicher Mängel auf der Qualitätssicherungsseite der Redaktion Informatik eingetragen. Dies geschieht, um die Qualität der Artikel aus dem <b>Themengebiet Informatik</b> auf ein akzeptables Niveau zu bringen. Hilf mit, die inhaltlichen Mängel dieses Artikels zu beseitigen, und beteilige dich an der <b>Diskussion!</b>&nbsp;<small>(<span id="NeuerAbschnitt" class=""><a class="external text" href="https://de.wikipedia.org/w/index.php?title=Wikipedia:Redaktion_Informatik/Qualit%C3%A4tssicherung&amp;action=edit&amp;section=new&amp;preload=Vorlage:$1&amp;preloadparams%5B%5D=Der+Artikel+beschreibt+nicht%2C+was+ein+%27%27frame+buffer%27%27+wirklich+ist+und+wie+er+funktioniert.+Stattdessen+werden+Details+%C3%BCber+verschiedene+Grafikmodi+erkl%C3%A4rt%2C+aber+nicht+der+frame+buffer+selbst.+Siehe+auch+%5B%5BDiskussion%3AFramebuffer%23Was+ist+ein+frame+buffer%3F%5D%5D+--%E2%80%A3%5B%5BBenutzer%3AY2kbug%7CAndreas%5D%5D%E2%80%A2%3Csmall%3E%5B%5BBenutzer+Diskussion%3AY2kbug%7C%E2%9A%96%5D%5D%3C%2Fsmall%3E+22%3A37%2C+18.+Dez.+2021+%28CET%29&amp;preloadtitle=%5B%5BFramebuffer%5D%5D"><span title="Am Seitenende Abschnitt hinzufügen: Wikipedia:Redaktion Informatik/Qualitätssicherung">+</span></a></span>)</small>
<p><br> <b>Begründung:</b> Der Artikel beschreibt nicht, was ein <i>frame buffer</i> wirklich ist und wie er funktioniert. Stattdessen werden Details über verschiedene Grafikmodi erklärt, aber nicht der frame buffer selbst. Siehe auch Diskussion:Framebuffer#Was ist ein frame buffer? --‣Andreas•<small>⚖</small> 22:37, 18. Dez. 2021 (CET)
</p>
</td></tr></tbody></table>
</div>
<p>Der <b>Framebuffer</b> oder <b>Bildspeicher</b> (englisch <i>frame</i> – Einzelbild, <i>buffer</i> – Zwischenspeicher) ist Teil des <a href="Grafikspeicher" title="Grafikspeicher">Grafikspeichers</a> von <a href="Computer" title="Computer">Computern</a> und entspricht einer <a href="Digitalisierung" title="Digitalisierung">digitalen</a> Kopie des <a href="Bildschirm" title="Bildschirm">Monitorbildes</a>. Das heißt, jedem Bildschirm<a href="Pixel" title="Pixel">pixel</a> kann genau ein bestimmter Bereich des Framebuffers zugewiesen werden, der dessen digital übersetzten Farbwert enthält. Seit den 1990er-Jahren befindet sich der Framebuffer vorwiegend auf der <a href="Grafikkarte" title="Grafikkarte">Grafikkarte</a>.
</p>

<div class="mw-heading mw-heading2"><h2 id="Speicherbedarf">Speicherbedarf</h2></div>
<p>Die minimal benötigte Größe des Framebuffers ist abhängig von zwei Faktoren: der verwendeten <a href="Farbtiefe_(Computergrafik)" title="Farbtiefe (Computergrafik)">Farbtiefe</a> (genauer: Pixelformat) und der verwendeten <a href="Bildaufl%C3%B6sung" title="Bildauflösung">Bildauflösung</a>.
</p>
<div class="mw-heading mw-heading3"><h3 id="Farbtiefe">Farbtiefe</h3></div>
<p>Die Farbtiefe des Framebuffers definiert die Maximalzahl der gleichzeitig auf dem Bildschirm angezeigten Farben oder Farbnuancen. Im Bereich der <a href="IBM-PC-kompatibler_Computer" title="IBM-PC-kompatibler Computer">IBM-PC-kompatiblen Computer</a> waren und sind die in der folgenden Aufstellung angegebenen Größen üblich. Die angegebenen Pixelformate geben an, wie viele Bits pro Pixel auf die einzelnen Farbkanäle (rot, grün, blau, <a href="Alphakanal" title="Alphakanal">Alphakanal</a>) vergeben werden – bei Farbmodi, die <a href="Indizierte_Farben" title="Indizierte Farben">indizierte Farben</a> (Paletten) benutzen, fehlt diese Angabe, weil sie keinen Sinn ergibt.
</p>
<ul><li>1 Bit pro Pixel, zwei Farben (normalerweise hell und dunkel bei einem <a href="Kathodenstrahlr%C3%B6hrenbildschirm#Computermonitore" title="Kathodenstrahlröhrenbildschirm">Monochrom-Monitor</a>)
<ul><li><a href="Monochrome_Display_Adapter" title="Monochrome Display Adapter">MDA</a></li></ul></li>
<li>2 Bit pro Pixel, vier Farben
<ul><li><a href="Color_Graphics_Adapter" title="Color Graphics Adapter">CGA</a>: Palette mit 4 Farben aus 16 möglichen</li></ul></li>
<li>4 Bit pro Pixel, 16 Farben
<ul><li><a href="Enhanced_Graphics_Adapter" title="Enhanced Graphics Adapter">EGA</a>: Palette mit 16 Farben aus 64 möglichen</li></ul></li>
<li>8 Bit pro Pixel, 256 Farben
<ul><li><a href="Video_Graphics_Array" title="Video Graphics Array">VGA</a>: Palette mit 256 Farben aus 262144 möglichen</li></ul></li>
<li>15 Bit pro Pixel, 32768 Farben
<ul><li>Real Color: Pixelformat 5-5-5, d.&nbsp;h. 5 Bit pro <a href="Farbkanal" title="Farbkanal">Farbkanal</a> (also 32 Intensitätsabstufungen pro Kanal)</li></ul></li>
<li>16 Bit pro Pixel, 65536 Farben
<ul><li><a href="High_Color" title="High Color">High Color</a>: Pixelformat 5-6-5, d.&nbsp;h. 5 Bit für Rot und Blau (32 Intensitätsabstufungen) und 6 Bit für Grün (64 Intensitätsabstufungen)</li>
<li>alternativ auch 4-4-4-4, d.&nbsp;h. 4 Bit pro Farbkanal (16 Intensitätsabstufungen), wobei die letzten vier Bits entweder ungenutzt sind oder als Alphakanal verwendet werden (s. 32 Bit True Color)</li></ul></li>
<li>24 Bit pro Pixel: 16777216 Farben
<ul><li><a href="True_Color" title="True Color">True Color</a>: Pixelformat 8-8-8, d.&nbsp;h. 8 Bit pro Farbkanal (256 Intensitätsabstufungen)</li></ul></li>
<li>32 Bit pro Pixel
<ul><li>True Color: Pixelformat 8-8-8-8, d.&nbsp;h. 8 Bit pro Farbkanal (256 Intensitätsabstufungen)</li>
<li>Die gegenüber 24 Bit True Color hinzugekommenen 8 Bit werden normalerweise nicht genutzt; auf Rechnern mit <a href="32-Bit-Architektur" title="32-Bit-Architektur">32-Bit-Architektur</a> ist die Verarbeitung von 32-Bit-Werten aber effizienter als die von 24-Bit-Werten, weil dies genau der <a href="Datenwort" title="Datenwort">Wortbreite</a> des Prozessors entspricht, weswegen trotz des 33&nbsp;% höheren Speicherbedarfs True-Color-Framebuffer meistens 32 Bit Farbtiefe benutzen.</li></ul></li></ul>
<p>Bei Grafikhardware, die mit <a href="Bitplane" title="Bitplane">Bitplanes</a> arbeitet (z.&nbsp;B. <a href="Amiga" title="Amiga">Amiga</a>), sind bei indizierten Farben auch 3, 5, 6 und 7 Bit pro Pixel mit dementsprechend 8, 32, 64 bzw. 128 Farben üblich.
</p><p>In der 3D-Computergrafik werden auch Framebuffer mit höherer Genauigkeit benutzt. Dort benötigt die Bestimmung der Farbe eines Pixels oftmals mehrere Rechenschritte, wobei bei jedem Zwischenergebnis <a href="Rundungsfehler" title="Rundungsfehler">Rundungsfehler</a> entstehen können, die bei herkömmlichen Framebufferformaten schnell sichtbar sind und störend wirken.
</p><p>Bei diesen genaueren Formaten interpretiert man die Farbkanalwerte als Kommawerte auf einer Skala von 0.0 bis 1.0, damit bei der Verwendung mehrerer Pixelformate die Handhabung vereinfacht wird.
</p>
<ul><li>FX8
<ul><li>pro Farbkanal 8 Bit <a href="Festkommazahl" title="Festkommazahl">Festkomma</a>, somit 256 Farbabstufungen linear skaliert</li>
<li>identisch mit oben genannten 32 Bit pro Pixel. Ob man die 256 verschiedenen Werte pro Farbkanal als ganze Zahl zwischen 0 und 255 oder als Festkommawert zwischen 0.0 und 1.0 <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle \left({\frac {\text{Wert}}{255}}\right)}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<mrow>
<mo>(</mo>
<mrow class="MJX-TeXAtom-ORD">
<mfrac>
<mtext>Wert</mtext>
<mn>255</mn>
</mfrac>
</mrow>
<mo>)</mo>
</mrow>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle \left({\frac {\text{Wert}}{255}}\right)}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/f7e22cd2d1a1da1d355926a41b1390cc7d1a7897.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -2.505ex; width:9.495ex; height:6.176ex;" alt="{\displaystyle \left({\frac {\text{Wert}}{255}}\right)}" loading="lazy"></span> auffasst, ist lediglich Interpretationssache.</li>
<li>maximaler Kontrast 255:1, daher geeignet für Low Dynamic Range (LDR) Rendering, wie es gewöhnliche Bildschirme aller Art anzeigen können</li></ul></li>
<li>FX12
<ul><li>pro Farbkanal 12 Bit Festkomma, somit 4096 Farbabstufungen linear skaliert</li>
<li>höhere Genauigkeit als FX8</li>
<li>maximaler Kontrast 4095:1, geeignet für Low Dynamic Range (LDR) Rendering</li></ul></li>
<li>FX16
<ul><li>pro Farbkanal 16 Bit Festkomma, somit 65536 Farbabstufungen linear skaliert</li>
<li>höhere Genauigkeit als FX12</li>
<li>maximaler Kontrast 65535:1, geeignet für Medium Dynamic Range (MDR) Rendering</li></ul></li>
<li>FP16
<ul><li>pro Farbkanal 16 Bit <a href="Gleitkommazahl" title="Gleitkommazahl">Gleitkomma</a> (davon 5 Bit <a href="Potenz_(Mathematik)" title="Potenz (Mathematik)">Exponent</a> und 10 Bit <a href="Mantisse" title="Mantisse">Mantisse</a>), somit 32768 Farbabstufungen exponentiell skaliert</li>
<li>Die exponentielle Skala erlaubt im Vergleich zu FX16 eine wesentlich feinere Auflösung bei kleinen Werten, bei größeren Werten ist es aber ungenauer.</li>
<li>maximaler Kontrast ca. <span class="mwe-math-element mwe-math-element-inline"><span class="mwe-math-mathml-inline mwe-math-mathml-a11y" style="display: none;"><math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle 10^{12}:1}">
<semantics>
<mrow class="MJX-TeXAtom-ORD">
<mstyle displaystyle="true" scriptlevel="0">
<msup>
<mn>10</mn>
<mrow class="MJX-TeXAtom-ORD">
<mn>12</mn>
</mrow>
</msup>
<mo>:</mo>
<mn>1</mn>
</mstyle>
</mrow>
<annotation encoding="application/x-tex">{\displaystyle 10^{12}:1}</annotation>
</semantics>
</math></span><img src="./_assets_/eb734a37dd21ce173a46342d1cc64c92/49bbdaa171f69f70455d60320828ba29745b73f5.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.338ex; width:7.301ex; height:2.676ex;" alt="{\displaystyle 10^{12}:1}" loading="lazy"></span>, geeignet für <a href="High_Dynamic_Range_Rendering" title="High Dynamic Range Rendering">High Dynamic Range (HDR) Rendering</a>.</li></ul></li>
<li>FP24
<ul><li>pro Farbkanal 24 Bit Gleitkomma (davon 7 Bit Exponent und 16 Bit Mantisse), somit mehr als 8 Mio. Farbabstufungen exponentiell skaliert</li>
<li>höhere Genauigkeit als FP16, daher sehr gut geeignet für HDR-Rendering</li></ul></li>
<li>FP32
<ul><li>pro Farbkanal 32 Bit Gleitkomma (davon 8 Bit Exponent und 23 Bit Mantisse), somit mehr als 2 Mrd. Farbabstufungen exponentiell skaliert</li>
<li>noch höhere Genauigkeit als FP24</li></ul></li></ul>
<div class="mw-heading mw-heading3"><h3 id="Bildauflösung"><span id="Bildaufl.C3.B6sung"></span>Bildauflösung</h3></div>
<p>Die Bildauflösung gibt an, aus wie vielen Pixeln der Framebuffer besteht. Üblicherweise gibt man hierbei die horizontale und vertikale Pixelanzahl an, wodurch man auch das <a href="Seitenverh%C3%A4ltnis" title="Seitenverhältnis">Seitenverhältnis</a> direkt berechnen kann, üblich sind hier 4:3, 5:4 und 16:10.
</p>
<table class="wikitable" style="text-align:center">
<caption>Typische Framebuffer-Auflösung
</caption>
<tbody><tr>
<th>Auflösung<br>(in Pixel)</th>
<th>Pixel-<br>anzahl</th>
<th>Seiten-<br>verhältnis
</th></tr>
<tr>
<td>320 × 200</td>
<td><span style="visibility:hidden;">0.0</span>64.000</td>
<td>16:10
</td></tr>
<tr>
<td>640 × 200</td>
<td><span style="visibility:hidden;">0.</span>128.000</td>
<td>32:10<style data-mw-deduplicate="TemplateStyles:r261937660">
/* start https://de.wikipedia.org/ */


.mw-parser-output .fussnoten-marke{font-style:normal;font-variant:normal;font-weight:normal;unicode-bidi:isolate;white-space:nowrap}.mw-parser-output sup.fussnoten-marke{font-size:0.75rem}.mw-parser-output .fussnoten-etui sup{margin-left:-0.15rem}.mw-parser-output span.fussnoten-inhalt{padding-left:0.1rem}.mw-parser-output span.fussnoten-inhalt+span.fussnoten-inhalt{padding-left:0.15rem}.mw-parser-output .fussnoten-block{margin-bottom:0.1rem}.mw-parser-output div.fussnoten-inhalt{display:inline-block;padding-left:0.8rem;text-indent:-0.8rem}.mw-parser-output div.fussnoten-inhalt p,.mw-parser-output div.fussnoten-inhalt dl,.mw-parser-output div.fussnoten-inhalt ol,.mw-parser-output div.fussnoten-inhalt ul{text-indent:0}.mw-parser-output div.fussnoten-inhalt.fussnoten-floatfix{display:block}.mw-parser-output .fussnoten-box{margin-top:0.5rem;padding-left:0.8rem}.mw-parser-output .fussnoten-box,.mw-parser-output div.fussnoten-inhalt{font-size:94%}.mw-parser-output .fussnoten-box div.fussnoten-inhalt,.mw-parser-output span.fussnoten-inhalt,.mw-parser-output .fussnoten-inhalt .reference-text{font-size:inherit}.mw-parser-output .fussnoten-inhalt .reference-text{display:inline}.mw-parser-output .fussnoten-linie{display:inline-block;position:relative;top:-1em;border-top:solid 1px #808080;width:8rem}.mw-parser-output .fussnoten-linie+p,.mw-parser-output .fussnoten-linie+dl,.mw-parser-output .fussnoten-linie+ol,.mw-parser-output .fussnoten-linie+ul,.mw-parser-output .fussnoten-linie+link+div{margin-top:-1em}.mw-parser-output .annotationpair-m:target .fussnoten-marke,.mw-parser-output .fussnoten-inhalt:target{background-color:var(--background-color-progressive-subtle,#f1f4fd);box-shadow:0 0 0 0.25em var(--background-color-progressive-subtle,#f1f4fd)}.mw-parser-output .annotationpair-m:target .fussnoten-marke,.mw-parser-output .fussnoten-inhalt:target .fussnoten-marke{font-weight:bold}


/* end https://de.wikipedia.org/ */
</style>&nbsp;<span class="fussnoten-etui reference"><sup class="fussnoten-marke" data-annotationpair-m="a">a</sup></span>
</td></tr>
<tr>
<td>640 × 480</td>
<td><span style="visibility:hidden;">0.</span>307.200</td>
<td>4:3
</td></tr>
<tr>
<td>800 × 600</td>
<td><span style="visibility:hidden;">0.</span>480.000</td>
<td>4:3
</td></tr>
<tr>
<td>1024 × 768<span style="visibility:hidden;">0</span></td>
<td><span style="visibility:hidden;">0.</span>786.432</td>
<td>4:3
</td></tr>
<tr>
<td>1280 × 1024</td>
<td>1.310.720</td>
<td>5:4
</td></tr>
<tr>
<td>1440 × 900<span style="visibility:hidden;">0</span></td>
<td>1.296.000</td>
<td>16:10
</td></tr>
<tr>
<td>1680 × 1050</td>
<td>1.764.000</td>
<td>16:10
</td></tr>
<tr>
<td>1600 × 1200</td>
<td>1.920.000</td>
<td>4:3
</td></tr>
<tr>
<td>1920 × 1200</td>
<td>2.304.000</td>
<td>16:10
</td></tr>
<tr>
<td>2048 × 1536</td>
<td>3.145.728</td>
<td>4:3
</td></tr>
<tr>
<td>2560 × 1600</td>
<td>4.096.000</td>
<td>16:10
</td></tr></tbody></table>
<div class="fussnoten-box">
<div class="fussnoten-linie" aria-hidden="true" role="presentation"></div>
<div class="fussnoten-block"><div class="fussnoten-inhalt references"><sup class="fussnoten-marke mw-cite-backlink" data-annotationpair-a="a">a</sup>&nbsp;<div class="reference-text">bei üblichen 4:3-Bildschirmen meist <a href="Anamorphe_Bildaufzeichnung" title="Anamorphe Bildaufzeichnung">anamorph</a> als 16:10 dargestellt</div></div></div>
</div>
<div class="mw-heading mw-heading2"><h2 id="Beispiele">Beispiele</h2></div>
<ul><li><a href="Textmodus" title="Textmodus">Textmodus</a> (z.&nbsp;B. beim <a href="Booten" title="Booten">Hochfahren</a> eines IBM-kompatiblen PCs mit <a href="BIOS_(IBM_PC)" title="BIOS (IBM PC)">BIOS</a>)<br>Bei einer 80&nbsp;×&nbsp;25 Zeichen großen Konsole, wobei jedes Zeichen und seine Farbe mit jeweils 8&nbsp;Bit (also zusammen 16&nbsp;Bit) gespeichert wird, belegt der Framebuffer 80&nbsp;×&nbsp;25&nbsp;×&nbsp;16 = 32000&nbsp;Bit = 4&nbsp;KB.</li>
<li>EFI-Framebuffer bei modernen PCs mit <a href="Unified_Extensible_Firmware_Interface" title="Unified Extensible Firmware Interface">Unified Extensible Firmware Interface</a> (UEFI)<br>Bei EFI 1.x war mit <i><span lang="en">Universal Graphics Adapter</span></i> (UGA) ein von der Hardware unabhängiger EFI-Treiber verfügbar, um einen einfachen Video-Framebuffer zu nutzen. Dieser wurde mit UEFI 2.x durch das <i><span lang="en">Graphics Output Protocol</span></i> (GOP) ersetzt, das nun auch den Textmodus unabhängig von der Grafikkarte nutzen kann. Sowohl UGA als auch GOP ersetzt das Video-BIOS (kurz VBIOS, nur auf PCs mit BIOS) vollständig – VBIOS-Funktionen sind somit auch vom Grafiktreiber nicht mehr nutzbar, sodass einige ältere PC-Grafiktreiber unter (U)EFI bei identischer Hardware nicht funktionieren, bei aktiviertem CSM (der BIOS-Emulation von EFI bzw. UEFI) jedoch schon. Betriebssysteme und <a href="Ger%C3%A4tetreiber" title="Gerätetreiber">Gerätetreiber</a> müssen daher EFI-UGA oder -GOP nutzen, um den Text- (bei GOP) oder Videomodus und weitere Firmware-Framebuffer-Funktionen nutzen zu können. Unter Linux existiert mit <samp>efifb</samp> ein generischer Framebuffer-Grafiktreiber, der auf allen EFI-PCs, und daher auch unabhängig von der spezifischen Grafikkarte, funktioniert.<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> Auch Windows und <a href="MacOS" title="MacOS">macOS</a> nutzen den EFI-Framebuffer, da er jedoch nur ohne Grafikbeschleunigung zur Verfügung steht, nur in einem eingeschränkten Modus.</li>
<li><a href="Grafikmodus" title="Grafikmodus">Grafikmodus</a> (z.&nbsp;B. unter <a href="Microsoft_Windows" title="Microsoft Windows">Windows</a> oder beim <a href="X_Window_System" title="X Window System">X&nbsp;Window System</a> unter <a href="Unix" title="Unix">Unix</a>)<br> Bei einer Bildschirmauflösung von 1024&nbsp;×&nbsp;768 Pixel und einer Farbtiefe von 24&nbsp;Bit belegt der Framebuffer 1024&nbsp;×&nbsp;768&nbsp;×&nbsp;24 = 18874368 Bit = 2,25 <a href="Bin%C3%A4rpr%C3%A4fix" title="Binärpräfix">MiB</a>.</li></ul>
<table class="wikitable">
<tbody><tr>
<th>Breite × Höhe × Farben
</th>
<th>Speicherbedarf &nbsp;<span class="fussnoten-etui reference"><sup class="fussnoten-marke" data-annotationpair-m="*">*</sup></span>
</th>
<th>Standard
</th></tr>
<tr align="right">
<td>320 × 200 × 2</td>
<td>≈ 8 KB<br>(8 kB)</td>
<td>C64
</td></tr>
<tr>
<td>320 × 200 × 16
</td>
<td>≈ 32 KB
<p>(32 kB)
</p>
</td>
<td>Atari ST
</td></tr>
<tr align="right">
<td>640 × 200 × 2</td>
<td>≈ 16 KB<br>(16 kB)</td>
<td>CGA
</td></tr>
<tr align="right">
<td>750 × 350 × 2</td>
<td>≈ 32 KB</td>
<td>Hercules
</td></tr>
<tr align="right">
<td>640 × 350 × 16</td>
<td>≈ 109 KB<br>(112 kB)</td>
<td>EGA
</td></tr>
<tr>
<td>640 × 400 × 1
</td>
<td>≈ 32 KB
<p>(32 kB)
</p>
</td>
<td>Atari ST
</td></tr>
<tr align="right">
<td>640 × 480 × 16</td>
<td>150 KB</td>
<td>VGA
</td></tr>
<tr align="right">
<td>320 × 200 × 256</td>
<td>62,5 KB<br>(64 kB)</td>
<td>VGA
</td></tr>
<tr align="right">
<td>640 × 480 × 256</td>
<td>300 KB</td>
<td>VGA-extended
</td></tr>
<tr align="right">
<td>800 × 600 × 256</td>
<td>468,75 KB<br>(480 kB)</td>
<td>SVGA
</td></tr>
<tr align="right">
<td>1024 × 768 × 256</td>
<td>768 KB</td>
<td>XGA
</td></tr>
<tr align="right">
<td>1024 × 768 × 64k</td>
<td>1,5 MB</td>
<td>XGA
</td></tr>
<tr align="right">
<td>1024 × 768 × TrueColor</td>
<td>2,25 MB</td>
<td>XGA
</td></tr>
<tr align="right">
<td>1280 × 960 × TrueColor</td>
<td>≈ 3,5 MB</td>
<td>SXGA
</td></tr>
<tr align="right">
<td>1400 × 1050 × TrueColor</td>
<td>≈ 4,2 MB</td>
<td>SXGA+
</td></tr>
<tr align="right">
<td>1600 × 1200 × TrueColor</td>
<td>≈ 5,5 MB</td>
<td>UXGA
</td></tr>
<tr align="right">
<td>1920 × 1200 × TrueColor</td>
<td>≈ 6,6 MB</td>
<td>WUXGA
</td></tr>
<tr align="right">
<td>2048 × 1536 × TrueColor</td>
<td>9 MB</td>
<td>SUXGA
</td></tr>
<tr align="right">
<td>2560 × 960 × TrueColor</td>
<td>≈ 7 MB</td>
<td>Dual SXGA
</td></tr>
<tr align="right">
<td>2560 × 1600 × TrueColor</td>
<td>≈ 12 MB</td>
<td>WQXGA
</td></tr></tbody></table>
<div class="fussnoten-box">
<div class="fussnoten-linie" aria-hidden="true" role="presentation"></div>
<div class="fussnoten-block"><div class="fussnoten-inhalt references"><sup class="fussnoten-marke mw-cite-backlink" data-annotationpair-a="*">*</sup>&nbsp;<div class="reference-text"><i>hier:</i> 1 KB = 1024 Byte und 1 kB = 1000 Byte</div></div></div>
</div>
<p>In der Übersicht wurde im Fall von TrueColor berücksichtigt, dass Daten intern mit 24&nbsp;Bit gespeichert werden.
</p>
<div class="mw-heading mw-heading2"><h2 id="Verbesserungen">Verbesserungen</h2></div>
<p>Durch Unzulänglichkeiten in der Kontinuität der Bildfolge, und um die allgemeine Darstellungsqualität weiter zu erhöhen, wurde das Konzept des Framebuffers im Laufe der Zeit überarbeitet. So entspricht ein Framebuffer auf aktuellen Systemen mehreren Pufferspeichern.
</p>
<ul><li>Bei der <a href="Doppelpufferung" title="Doppelpufferung">Doppelpufferung</a> (<i>double buffering</i>) wird der Framebuffer in zwei Bereiche (<i>Frontbuffer</i> und <i>Backbuffer</i>) unterteilt.</li>
<li>Bei der <a href="Dreifachpufferung" title="Dreifachpufferung">Dreifachpufferung</a> (<i>triple buffering</i>) wird der Framebuffer in drei Bereiche (1 <i>Frontbuffer</i> und 2 <i>Backbuffer</i>) unterteilt.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Linux-Framebuffer">Linux-Framebuffer</h2></div>

<p>Das <i>Linux Framebuffer Device</i> (kurz <i>fbdev</i>) ist eine hardwareunabhängige Abstraktionsschicht unter <a href="Linux" title="Linux">Linux</a>, um Grafiken auf der Konsole bzw. mit X-Window (xf86_fbdev) anzuzeigen. Dabei setzt das Framebuffer-Device nicht auf systemspezifischen Bibliotheken wie der SVGALib oder dem <a href="X_Window_System" title="X Window System">X&nbsp;Window System</a> auf und ist somit eine ressourcensparende Alternative zum weiterverbreiteten X-Server, auf dem heute die meisten grafischen Oberflächen für Linux aufbauen. Es ist seit der Linux-Kernelversion 2.1.107 für alle Plattformen im Standardkernel enthalten.
</p><p>Ursprünglich wurde es für <a href="Linux68k" title="Linux68k">Linux68k</a> implementiert, um auf entsprechenden Systemen (Amiga, Atari, Macintosh) mit einer geringen Hardwarebeschleunigung einen <a href="Textmodus" title="Textmodus">Textmodus</a> zu emulieren und wurde erst später auf die IBM-PC-kompatible Plattform erweitert.
</p><p>Heutzutage kann der Framebuffer direkt von verschiedenen Programmen wie <a href="MPlayer" title="MPlayer">MPlayer</a> und Bibliotheken wie GGI, <a href="Simple_DirectMedia_Layer" title="Simple DirectMedia Layer">SDL</a>, <a href="GTK_(Programmbibliothek)" title="GTK (Programmbibliothek)">GTK</a> und <a href="Qt_(Bibliothek)" title="Qt (Bibliothek)">Qt Extended</a> benutzt werden. Das ressourcensparende Konzept macht den Einsatz besonders für eingebettete Systeme interessant.
</p><p>Insbesondere wird es von verschiedenen Distributionen (<a href="Ubuntu_(Betriebssystem)" title="Ubuntu (Betriebssystem)">Ubuntu</a>, <a href="OpenSUSE" title="OpenSUSE">openSUSE</a>) verwendet, um schon während des Bootstrappings in Form eines <a href="Splash_Screen" title="Splash Screen">Splash Screens</a> eine grafische Ausgabe zu ermöglichen.
</p><p>Der am häufigsten verwendete <a href="Video_Electronics_Standards_Association" title="Video Electronics Standards Association">VESA</a>-Framebuffer-Treiber (vesafb) baut auf einheitlichen Spezifikationen von Videostandards auf und erlaubt so einen Zugriff auf Grafikkarten größtenteils unabhängig vom Hersteller. Dadurch ist dann auch eine quelloffene Implementation möglich. Außerdem wurden von diversen Grafikchipherstellern (<a href="Nvidia" title="Nvidia">Nvidia</a>: rivafb, nvidiafb; <a href="AMD" title="AMD">AMD</a>: radeonfb) <a href="Bin%C3%A4rblob" title="Binärblob">proprietäre Treiber</a> auf den Markt gebracht.
</p><p>Bekannt wurde das Framebuffer-Device durch die Möglichkeit, während des Linux-Kernel-Ladevorgangs dem Benutzer ein <a href="Tux_(Maskottchen)" title="Tux (Maskottchen)">Tux</a>-Logo anzuzeigen. Dazu muss es aber zunächst im Kernel enthalten sein und beim nächsten Reboot durch den <a href="Bootloader" title="Bootloader">Bootloader</a>, der auch das Betriebssystem in den Arbeitsspeicher lädt, durch die Angabe des Parameters <code>video</code> aktiviert werden.
</p><p>Im Folgenden werden zwei Beispiele gezeigt, in denen ein AMD-Treiber mit einer Bildauflösung von 1024×768 Bildpunkten bei einer Farbtiefe von 8&nbsp;Bit pro Pixel und einer Bildwiederholungsfrequenz von 76&nbsp;Hz geladen wird:
</p>
<dl><dt>Beispiel für eine LILO Konfigurationsdatei</dt>
<dd></dd></dl>
<pre># LILO configuration file
boot = /dev/sda1
# Linux bootable partition config begins
image = /vmlinuz
append = "video=atyfb:1024x768-8@76,font:SUN8x16"
</pre>
<dl><dt>Beispiel für eine GRUB Konfigurationsdatei</dt>
<dd></dd></dl>
<pre># GRUB configuration file
# For booting LINUX
title Linux
kernel (hd0, 0) /vmlinuz video=atyfb:1024x768-8@76,font:SUN8x16 root=/dev/hda1
</pre>
<p>Für einen Hardwarezugriff auf das Framebuffer-Device muss nicht unbedingt ein Kernelmodul geschrieben werden. Ferner hat die Anwendung die Möglichkeit, im User-Mode über die Gerätedatei <code>/dev/fb*</code> auf das Device zuzugreifen und in den Grafikspeicher zu schreiben. In folgendem Beispiel wird demonstriert, wie mit der <a href="C_(Programmiersprache)" title="C (Programmiersprache)">Programmiersprache&nbsp;C</a> linear in den Framebuffer geschrieben werden kann. Hier wird der hexadezimale Wert 0x000000FF (Binär: 0b00000000000000000000000011111111) für jedes Pixel gesetzt:
</p>
<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;sys/types.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;sys/stat.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;sys/mman.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;sys/ioctl.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;fcntl.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;linux/fb.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;unistd.h&gt;</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">argc</span><span class="p">,</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">**</span><span class="n">argv</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">row</span><span class="p">,</span><span class="w"> </span><span class="n">col</span><span class="p">,</span><span class="w"> </span><span class="n">width</span><span class="p">,</span><span class="w"> </span><span class="n">height</span><span class="p">,</span><span class="w"> </span><span class="n">bitspp</span><span class="p">,</span><span class="w"> </span><span class="n">bytespp</span><span class="p">;</span>
<span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="o">*</span><span class="n">data</span><span class="p">;</span>

<span class="w"> </span><span class="c1">// Öffnen des Gerätes</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">open</span><span class="p">(</span><span class="s">"/dev/fb0"</span><span class="p">,</span><span class="w"> </span><span class="n">O_RDWR</span><span class="p">);</span>

<span class="w"> </span><span class="c1">// Informationen über den Framebuffer einholen</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">fb_var_screeninfo</span><span class="w"> </span><span class="n">screeninfo</span><span class="p">;</span>
<span class="w"> </span><span class="n">ioctl</span><span class="p">(</span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FBIOGET_VSCREENINFO</span><span class="p">,</span><span class="w"> </span><span class="o">&amp;</span><span class="n">screeninfo</span><span class="p">);</span>

<span class="w"> </span><span class="c1">// Beende, wenn die Farbauflösung nicht 32 Bit pro Pixel entspricht</span>
<span class="w"> </span><span class="n">bitspp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">screeninfo</span><span class="p">.</span><span class="n">bits_per_pixel</span><span class="p">;</span>
<span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">bitspp</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="mi">32</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">// Ausgabe der Fehlermeldung</span>
<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">"Farbaufloesung = %i Bits pro Pixel</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span><span class="w"> </span><span class="n">bitspp</span><span class="p">);</span>
<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">"Bitte aendern Sie die Farbtiefe auf 32 Bits pro Pixel</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="w"> </span><span class="n">close</span><span class="p">(</span><span class="n">fd</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"> </span><span class="c1">// Für den Programmabbruch geben wir einen Rückgabetyp&nbsp;!= 0 aus.</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="n">width</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">screeninfo</span><span class="p">.</span><span class="n">xres</span><span class="p">;</span>
<span class="w"> </span><span class="n">height</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">screeninfo</span><span class="p">.</span><span class="n">yres</span><span class="p">;</span>
<span class="w"> </span><span class="n">bytespp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bitspp</span><span class="o">/</span><span class="mi">8</span><span class="p">;</span><span class="w"> </span><span class="c1">//Bytes pro Pixel berechnen</span>

<span class="w"> </span><span class="c1">// Überprüfen ob der Typ unsigned int die gleiche Byte-Grösse wie ein Pixel besitzt.</span>
<span class="w"> </span><span class="c1">// In unserem Fall 4 Byte (32 Bit), falls nicht wird das Programm beendet</span>
<span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="k">sizeof</span><span class="p">(</span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">bytespp</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">close</span><span class="p">(</span><span class="n">fd</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>

<span class="w"> </span><span class="c1">// Zeiger auf den Framebufferspeicher anfordern</span>
<span class="w"> </span><span class="n">data</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="o">*</span><span class="p">)</span><span class="w"> </span><span class="n">mmap</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">width</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">height</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">bytespp</span><span class="p">,</span><span class="w"> </span><span class="n">PROT_READ</span><span class="w"> </span><span class="o">|</span><span class="w"> </span><span class="n">PROT_WRITE</span><span class="p">,</span><span class="w"> </span><span class="n">MAP_SHARED</span><span class="p">,</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>

<span class="w"> </span><span class="c1">// In den Framebuffer-Speicher schreiben. Hier wird Pixel für Pixel auf</span>
<span class="w"> </span><span class="c1">// die Farbe 0x000000FF (Blau) gesetzt, da ein Pixel das AARRGGBB Format hat</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="n">row</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">row</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">height</span><span class="p">;</span><span class="w"> </span><span class="n">row</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="k">for</span><span class="p">(</span><span class="n">col</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">col</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">width</span><span class="p">;</span><span class="w"> </span><span class="n">col</span><span class="o">++</span><span class="p">)</span>
<span class="w"> </span><span class="n">data</span><span class="p">[</span><span class="n">row</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">width</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">col</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mh">0xFF</span><span class="p">;</span>

<span class="w"> </span><span class="c1">// Zeiger wieder freigeben</span>
<span class="w"> </span><span class="n">munmap</span><span class="p">(</span><span class="n">data</span><span class="p">,</span><span class="w"> </span><span class="n">width</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">height</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">bytespp</span><span class="p">);</span>

<span class="w"> </span><span class="c1">// Gerät schließen</span>
<span class="w"> </span><span class="n">close</span><span class="p">(</span><span class="n">fd</span><span class="p">);</span>
<span class="w"> </span><span class="c1">// Rückgabewert</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Siehe_auch">Siehe auch</h2></div>
<ul><li><a href="DirectFB" title="DirectFB">DirectFB</a>, Direct frame buffer, eine auf dem Linux frame buffer aufsetzende Programmbibliothek</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>
<ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><a href="#cite_ref-1">↑</a></span> <span class="reference-text"><span class="cite">Edgar Hucek: <a rel="nofollow" class="external text" href="https://www.kernel.org/doc/html/latest/fb/efifb.html"><i>What is efifb?</i></a> In: <i>The Linux Kernel Archives.</i><span class="Abrufdatum"> Abgerufen am 25.&nbsp;August 2020</span> (englisch).</span><span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&amp;rfr_id=info%3Asid%2Fde.wikipedia.org%3AFramebuffer&amp;rft.title=What+is+efifb%3F&amp;rft.description=What+is+efifb%3F&amp;rft.identifier=https%3A%2F%2Fwww.kernel.org%2Fdoc%2Fhtml%2Flatest%2Ffb%2Fefifb.html&amp;rft.creator=Edgar+Hucek&amp;rft.language=en">&nbsp;</span></span>
</li>
</ol></div><!--htdig_noindex--><div><div class="zim-footer">
Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-05-26" href="https://de.wikipedia.org/wiki/?title=Framebuffer&amp;oldid=256356104">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>

</body></html>